// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2009-2014 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_SPARSE_SELFADJOINTVIEW_H
#define EIGEN_SPARSE_SELFADJOINTVIEW_H

namespace Eigen {

/** \ingroup SparseCore_Module
 * \class SparseSelfAdjointView
 *
 * \brief Pseudo expression to manipulate a triangular sparse matrix as a selfadjoint matrix.
 *
 * \param MatrixType the type of the dense matrix storing the coefficients
 * \param Mode can be either \c #Lower or \c #Upper
 *
 * This class is an expression of a sefladjoint matrix from a triangular part of a matrix
 * with given dense storage of the coefficients. It is the return type of MatrixBase::selfadjointView()
 * and most of the time this is the only way that it is used.
 *
 * \sa SparseMatrixBase::selfadjointView()
 */
namespace internal {

template<typename MatrixType, unsigned int Mode>
struct traits<SparseSelfAdjointView<MatrixType, Mode>> : traits<MatrixType>
{};

template<int SrcMode, int DstMode, typename MatrixType, int DestOrder>
void
permute_symm_to_symm(const MatrixType& mat,
					 SparseMatrix<typename MatrixType::Scalar, DestOrder, typename MatrixType::StorageIndex>& _dest,
					 const typename MatrixType::StorageIndex* perm = 0);

template<int Mode, typename MatrixType, int DestOrder>
void
permute_symm_to_fullsymm(const MatrixType& mat,
						 SparseMatrix<typename MatrixType::Scalar, DestOrder, typename MatrixType::StorageIndex>& _dest,
						 const typename MatrixType::StorageIndex* perm = 0);

}

template<typename MatrixType, unsigned int _Mode>
class SparseSelfAdjointView : public EigenBase<SparseSelfAdjointView<MatrixType, _Mode>>
{
  public:
	enum
	{
		Mode = _Mode,
		TransposeMode = ((Mode & Upper) ? Lower : 0) | ((Mode & Lower) ? Upper : 0),
		RowsAtCompileTime = internal::traits<SparseSelfAdjointView>::RowsAtCompileTime,
		ColsAtCompileTime = internal::traits<SparseSelfAdjointView>::ColsAtCompileTime
	};

	typedef EigenBase<SparseSelfAdjointView> Base;
	typedef typename MatrixType::Scalar Scalar;
	typedef typename MatrixType::StorageIndex StorageIndex;
	typedef Matrix<StorageIndex, Dynamic, 1> VectorI;
	typedef typename internal::ref_selector<MatrixType>::non_const_type MatrixTypeNested;
	typedef typename internal::remove_all<MatrixTypeNested>::type _MatrixTypeNested;

	explicit inline SparseSelfAdjointView(MatrixType& matrix)
		: m_matrix(matrix)
	{
		eigen_assert(rows() == cols() && "SelfAdjointView is only for squared matrices");
	}

	inline Index rows() const { return m_matrix.rows(); }
	inline Index cols() const { return m_matrix.cols(); }

	/** \internal \returns a reference to the nested matrix */
	const _MatrixTypeNested& matrix() const { return m_matrix; }
	typename internal::remove_reference<MatrixTypeNested>::type& matrix() { return m_matrix; }

	/** \returns an expression of the matrix product between a sparse self-adjoint matrix \c *this and a sparse matrix
	 * \a rhs.
	 *
	 * Note that there is no algorithmic advantage of performing such a product compared to a general sparse-sparse
	 * matrix product. Indeed, the SparseSelfadjointView operand is first copied into a temporary SparseMatrix before
	 * computing the product.
	 */
	template<typename OtherDerived>
	Product<SparseSelfAdjointView, OtherDerived> operator*(const SparseMatrixBase<OtherDerived>& rhs) const
	{
		return Product<SparseSelfAdjointView, OtherDerived>(*this, rhs.derived());
	}

	/** \returns an expression of the matrix product between a sparse matrix \a lhs and a sparse self-adjoint matrix \a
	 * rhs.
	 *
	 * Note that there is no algorithmic advantage of performing such a product compared to a general sparse-sparse
	 * matrix product. Indeed, the SparseSelfadjointView operand is first copied into a temporary SparseMatrix before
	 * computing the product.
	 */
	template<typename OtherDerived>
	friend Product<OtherDerived, SparseSelfAdjointView> operator*(const SparseMatrixBase<OtherDerived>& lhs,
																  const SparseSelfAdjointView& rhs)
	{
		return Product<OtherDerived, SparseSelfAdjointView>(lhs.derived(), rhs);
	}

	/** Efficient sparse self-adjoint matrix times dense vector/matrix product */
	template<typename OtherDerived>
	Product<SparseSelfAdjointView, OtherDerived> operator*(const MatrixBase<OtherDerived>& rhs) const
	{
		return Product<SparseSelfAdjointView, OtherDerived>(*this, rhs.derived());
	}

	/** Efficient dense vector/matrix times sparse self-adjoint matrix product */
	template<typename OtherDerived>
	friend Product<OtherDerived, SparseSelfAdjointView> operator*(const MatrixBase<OtherDerived>& lhs,
																  const SparseSelfAdjointView& rhs)
	{
		return Product<OtherDerived, SparseSelfAdjointView>(lhs.derived(), rhs);
	}

	/** Perform a symmetric rank K update of the selfadjoint matrix \c *this:
	 * \f$ this = this + \alpha ( u u^* ) \f$ where \a u is a vector or matrix.
	 *
	 * \returns a reference to \c *this
	 *
	 * To perform \f$ this = this + \alpha ( u^* u ) \f$ you can simply
	 * call this function with u.adjoint().
	 */
	template<typename DerivedU>
	SparseSelfAdjointView& rankUpdate(const SparseMatrixBase<DerivedU>& u, const Scalar& alpha = Scalar(1));

	/** \returns an expression of P H P^-1 */
	// TODO implement twists in a more evaluator friendly fashion
	SparseSymmetricPermutationProduct<_MatrixTypeNested, Mode> twistedBy(
		const PermutationMatrix<Dynamic, Dynamic, StorageIndex>& perm) const
	{
		return SparseSymmetricPermutationProduct<_MatrixTypeNested, Mode>(m_matrix, perm);
	}

	template<typename SrcMatrixType, int SrcMode>
	SparseSelfAdjointView& operator=(const SparseSymmetricPermutationProduct<SrcMatrixType, SrcMode>& permutedMatrix)
	{
		internal::call_assignment_no_alias_no_transpose(*this, permutedMatrix);
		return *this;
	}

	SparseSelfAdjointView& operator=(const SparseSelfAdjointView& src)
	{
		PermutationMatrix<Dynamic, Dynamic, StorageIndex> pnull;
		return *this = src.twistedBy(pnull);
	}

	// Since we override the copy-assignment operator, we need to explicitly re-declare the copy-constructor
	EIGEN_DEFAULT_COPY_CONSTRUCTOR(SparseSelfAdjointView)

	template<typename SrcMatrixType, unsigned int SrcMode>
	SparseSelfAdjointView& operator=(const SparseSelfAdjointView<SrcMatrixType, SrcMode>& src)
	{
		PermutationMatrix<Dynamic, Dynamic, StorageIndex> pnull;
		return *this = src.twistedBy(pnull);
	}

	void resize(Index rows, Index cols)
	{
		EIGEN_ONLY_USED_FOR_DEBUG(rows);
		EIGEN_ONLY_USED_FOR_DEBUG(cols);
		eigen_assert(rows == this->rows() && cols == this->cols() &&
					 "SparseSelfadjointView::resize() does not actually allow to resize.");
	}

  protected:
	MatrixTypeNested m_matrix;
	// mutable VectorI m_countPerRow;
	// mutable VectorI m_countPerCol;
  private:
	template<typename Dest>
	void evalTo(Dest&) const;
};

/***************************************************************************
 * Implementation of SparseMatrixBase methods
 ***************************************************************************/

template<typename Derived>
template<unsigned int UpLo>
typename SparseMatrixBase<Derived>::template ConstSelfAdjointViewReturnType<UpLo>::Type
SparseMatrixBase<Derived>::selfadjointView() const
{
	return SparseSelfAdjointView<const Derived, UpLo>(derived());
}

template<typename Derived>
template<unsigned int UpLo>
typename SparseMatrixBase<Derived>::template SelfAdjointViewReturnType<UpLo>::Type
SparseMatrixBase<Derived>::selfadjointView()
{
	return SparseSelfAdjointView<Derived, UpLo>(derived());
}

/***************************************************************************
 * Implementation of SparseSelfAdjointView methods
 ***************************************************************************/

template<typename MatrixType, unsigned int Mode>
template<typename DerivedU>
SparseSelfAdjointView<MatrixType, Mode>&
SparseSelfAdjointView<MatrixType, Mode>::rankUpdate(const SparseMatrixBase<DerivedU>& u, const Scalar& alpha)
{
	SparseMatrix<Scalar, (MatrixType::Flags & RowMajorBit) ? RowMajor : ColMajor> tmp = u * u.adjoint();
	if (alpha == Scalar(0))
		m_matrix = tmp.template triangularView<Mode>();
	else
		m_matrix += alpha * tmp.template triangularView<Mode>();

	return *this;
}

namespace internal {

// TODO currently a selfadjoint expression has the form SelfAdjointView<.,.>
//      in the future selfadjoint-ness should be defined by the expression traits
//      such that Transpose<SelfAdjointView<.,.> > is valid. (currently TriangularBase::transpose() is overloaded to
//      make it work)
template<typename MatrixType, unsigned int Mode>
struct evaluator_traits<SparseSelfAdjointView<MatrixType, Mode>>
{
	typedef typename storage_kind_to_evaluator_kind<typename MatrixType::StorageKind>::Kind Kind;
	typedef SparseSelfAdjointShape Shape;
};

struct SparseSelfAdjoint2Sparse
{};

template<>
struct AssignmentKind<SparseShape, SparseSelfAdjointShape>
{
	typedef SparseSelfAdjoint2Sparse Kind;
};
template<>
struct AssignmentKind<SparseSelfAdjointShape, SparseShape>
{
	typedef Sparse2Sparse Kind;
};

template<typename DstXprType, typename SrcXprType, typename Functor>
struct Assignment<DstXprType, SrcXprType, Functor, SparseSelfAdjoint2Sparse>
{
	typedef typename DstXprType::StorageIndex StorageIndex;
	typedef internal::assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar> AssignOpType;

	template<typename DestScalar, int StorageOrder>
	static void run(SparseMatrix<DestScalar, StorageOrder, StorageIndex>& dst,
					const SrcXprType& src,
					const AssignOpType& /*func*/)
	{
		internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), dst);
	}

	// FIXME: the handling of += and -= in sparse matrices should be cleanup so that next two overloads could be reduced
	// to:
	template<typename DestScalar, int StorageOrder, typename AssignFunc>
	static void run(SparseMatrix<DestScalar, StorageOrder, StorageIndex>& dst,
					const SrcXprType& src,
					const AssignFunc& func)
	{
		SparseMatrix<DestScalar, StorageOrder, StorageIndex> tmp(src.rows(), src.cols());
		run(tmp, src, AssignOpType());
		call_assignment_no_alias_no_transpose(dst, tmp, func);
	}

	template<typename DestScalar, int StorageOrder>
	static void run(SparseMatrix<DestScalar, StorageOrder, StorageIndex>& dst,
					const SrcXprType& src,
					const internal::add_assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>& /* func */)
	{
		SparseMatrix<DestScalar, StorageOrder, StorageIndex> tmp(src.rows(), src.cols());
		run(tmp, src, AssignOpType());
		dst += tmp;
	}

	template<typename DestScalar, int StorageOrder>
	static void run(SparseMatrix<DestScalar, StorageOrder, StorageIndex>& dst,
					const SrcXprType& src,
					const internal::sub_assign_op<typename DstXprType::Scalar, typename SrcXprType::Scalar>& /* func */)
	{
		SparseMatrix<DestScalar, StorageOrder, StorageIndex> tmp(src.rows(), src.cols());
		run(tmp, src, AssignOpType());
		dst -= tmp;
	}

	template<typename DestScalar>
	static void run(DynamicSparseMatrix<DestScalar, ColMajor, StorageIndex>& dst,
					const SrcXprType& src,
					const AssignOpType& /*func*/)
	{
		// TODO directly evaluate into dst;
		SparseMatrix<DestScalar, ColMajor, StorageIndex> tmp(dst.rows(), dst.cols());
		internal::permute_symm_to_fullsymm<SrcXprType::Mode>(src.matrix(), tmp);
		dst = tmp;
	}
};

} // end namespace internal

/***************************************************************************
 * Implementation of sparse self-adjoint time dense matrix
 ***************************************************************************/

namespace internal {

template<int Mode, typename SparseLhsType, typename DenseRhsType, typename DenseResType, typename AlphaType>
inline void
sparse_selfadjoint_time_dense_product(const SparseLhsType& lhs,
									  const DenseRhsType& rhs,
									  DenseResType& res,
									  const AlphaType& alpha)
{
	EIGEN_ONLY_USED_FOR_DEBUG(alpha);

	typedef typename internal::nested_eval<SparseLhsType, DenseRhsType::MaxColsAtCompileTime>::type SparseLhsTypeNested;
	typedef typename internal::remove_all<SparseLhsTypeNested>::type SparseLhsTypeNestedCleaned;
	typedef evaluator<SparseLhsTypeNestedCleaned> LhsEval;
	typedef typename LhsEval::InnerIterator LhsIterator;
	typedef typename SparseLhsType::Scalar LhsScalar;

	enum
	{
		LhsIsRowMajor = (LhsEval::Flags & RowMajorBit) == RowMajorBit,
		ProcessFirstHalf = ((Mode & (Upper | Lower)) == (Upper | Lower)) || ((Mode & Upper) && !LhsIsRowMajor) ||
						   ((Mode & Lower) && LhsIsRowMajor),
		ProcessSecondHalf = !ProcessFirstHalf
	};

	SparseLhsTypeNested lhs_nested(lhs);
	LhsEval lhsEval(lhs_nested);

	// work on one column at once
	for (Index k = 0; k < rhs.cols(); ++k) {
		for (Index j = 0; j < lhs.outerSize(); ++j) {
			LhsIterator i(lhsEval, j);
			// handle diagonal coeff
			if (ProcessSecondHalf) {
				while (i && i.index() < j)
					++i;
				if (i && i.index() == j) {
					res.coeffRef(j, k) += alpha * i.value() * rhs.coeff(j, k);
					++i;
				}
			}

			// premultiplied rhs for scatters
			typename ScalarBinaryOpTraits<AlphaType, typename DenseRhsType::Scalar>::ReturnType rhs_j(alpha *
																									  rhs(j, k));
			// accumulator for partial scalar product
			typename DenseResType::Scalar res_j(0);
			for (; (ProcessFirstHalf ? i && i.index() < j : i); ++i) {
				LhsScalar lhs_ij = i.value();
				if (!LhsIsRowMajor)
					lhs_ij = numext::conj(lhs_ij);
				res_j += lhs_ij * rhs.coeff(i.index(), k);
				res(i.index(), k) += numext::conj(lhs_ij) * rhs_j;
			}
			res.coeffRef(j, k) += alpha * res_j;

			// handle diagonal coeff
			if (ProcessFirstHalf && i && (i.index() == j))
				res.coeffRef(j, k) += alpha * i.value() * rhs.coeff(j, k);
		}
	}
}

template<typename LhsView, typename Rhs, int ProductType>
struct generic_product_impl<LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType>
	: generic_product_impl_base<LhsView,
								Rhs,
								generic_product_impl<LhsView, Rhs, SparseSelfAdjointShape, DenseShape, ProductType>>
{
	template<typename Dest>
	static void scaleAndAddTo(Dest& dst, const LhsView& lhsView, const Rhs& rhs, const typename Dest::Scalar& alpha)
	{
		typedef typename LhsView::_MatrixTypeNested Lhs;
		typedef typename nested_eval<Lhs, Dynamic>::type LhsNested;
		typedef typename nested_eval<Rhs, Dynamic>::type RhsNested;
		LhsNested lhsNested(lhsView.matrix());
		RhsNested rhsNested(rhs);

		internal::sparse_selfadjoint_time_dense_product<LhsView::Mode>(lhsNested, rhsNested, dst, alpha);
	}
};

template<typename Lhs, typename RhsView, int ProductType>
struct generic_product_impl<Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType>
	: generic_product_impl_base<Lhs,
								RhsView,
								generic_product_impl<Lhs, RhsView, DenseShape, SparseSelfAdjointShape, ProductType>>
{
	template<typename Dest>
	static void scaleAndAddTo(Dest& dst, const Lhs& lhs, const RhsView& rhsView, const typename Dest::Scalar& alpha)
	{
		typedef typename RhsView::_MatrixTypeNested Rhs;
		typedef typename nested_eval<Lhs, Dynamic>::type LhsNested;
		typedef typename nested_eval<Rhs, Dynamic>::type RhsNested;
		LhsNested lhsNested(lhs);
		RhsNested rhsNested(rhsView.matrix());

		// transpose everything
		Transpose<Dest> dstT(dst);
		internal::sparse_selfadjoint_time_dense_product<RhsView::TransposeMode>(
			rhsNested.transpose(), lhsNested.transpose(), dstT, alpha);
	}
};

// NOTE: these two overloads are needed to evaluate the sparse selfadjoint view into a full sparse matrix
// TODO: maybe the copy could be handled by generic_product_impl so that these overloads would not be needed anymore

template<typename LhsView, typename Rhs, int ProductTag>
struct product_evaluator<Product<LhsView, Rhs, DefaultProduct>, ProductTag, SparseSelfAdjointShape, SparseShape>
	: public evaluator<typename Product<typename Rhs::PlainObject, Rhs, DefaultProduct>::PlainObject>
{
	typedef Product<LhsView, Rhs, DefaultProduct> XprType;
	typedef typename XprType::PlainObject PlainObject;
	typedef evaluator<PlainObject> Base;

	product_evaluator(const XprType& xpr)
		: m_lhs(xpr.lhs())
		, m_result(xpr.rows(), xpr.cols())
	{
		::new (static_cast<Base*>(this)) Base(m_result);
		generic_product_impl<typename Rhs::PlainObject, Rhs, SparseShape, SparseShape, ProductTag>::evalTo(
			m_result, m_lhs, xpr.rhs());
	}

  protected:
	typename Rhs::PlainObject m_lhs;
	PlainObject m_result;
};

template<typename Lhs, typename RhsView, int ProductTag>
struct product_evaluator<Product<Lhs, RhsView, DefaultProduct>, ProductTag, SparseShape, SparseSelfAdjointShape>
	: public evaluator<typename Product<Lhs, typename Lhs::PlainObject, DefaultProduct>::PlainObject>
{
	typedef Product<Lhs, RhsView, DefaultProduct> XprType;
	typedef typename XprType::PlainObject PlainObject;
	typedef evaluator<PlainObject> Base;

	product_evaluator(const XprType& xpr)
		: m_rhs(xpr.rhs())
		, m_result(xpr.rows(), xpr.cols())
	{
		::new (static_cast<Base*>(this)) Base(m_result);
		generic_product_impl<Lhs, typename Lhs::PlainObject, SparseShape, SparseShape, ProductTag>::evalTo(
			m_result, xpr.lhs(), m_rhs);
	}

  protected:
	typename Lhs::PlainObject m_rhs;
	PlainObject m_result;
};

} // namespace internal

/***************************************************************************
 * Implementation of symmetric copies and permutations
 ***************************************************************************/
namespace internal {

template<int Mode, typename MatrixType, int DestOrder>
void
permute_symm_to_fullsymm(const MatrixType& mat,
						 SparseMatrix<typename MatrixType::Scalar, DestOrder, typename MatrixType::StorageIndex>& _dest,
						 const typename MatrixType::StorageIndex* perm)
{
	typedef typename MatrixType::StorageIndex StorageIndex;
	typedef typename MatrixType::Scalar Scalar;
	typedef SparseMatrix<Scalar, DestOrder, StorageIndex> Dest;
	typedef Matrix<StorageIndex, Dynamic, 1> VectorI;
	typedef evaluator<MatrixType> MatEval;
	typedef typename evaluator<MatrixType>::InnerIterator MatIterator;

	MatEval matEval(mat);
	Dest& dest(_dest.derived());
	enum
	{
		StorageOrderMatch = int(Dest::IsRowMajor) == int(MatrixType::IsRowMajor)
	};

	Index size = mat.rows();
	VectorI count;
	count.resize(size);
	count.setZero();
	dest.resize(size, size);
	for (Index j = 0; j < size; ++j) {
		Index jp = perm ? perm[j] : j;
		for (MatIterator it(matEval, j); it; ++it) {
			Index i = it.index();
			Index r = it.row();
			Index c = it.col();
			Index ip = perm ? perm[i] : i;
			if (Mode == int(Upper | Lower))
				count[StorageOrderMatch ? jp : ip]++;
			else if (r == c)
				count[ip]++;
			else if ((Mode == Lower && r > c) || (Mode == Upper && r < c)) {
				count[ip]++;
				count[jp]++;
			}
		}
	}
	Index nnz = count.sum();

	// reserve space
	dest.resizeNonZeros(nnz);
	dest.outerIndexPtr()[0] = 0;
	for (Index j = 0; j < size; ++j)
		dest.outerIndexPtr()[j + 1] = dest.outerIndexPtr()[j] + count[j];
	for (Index j = 0; j < size; ++j)
		count[j] = dest.outerIndexPtr()[j];

	// copy data
	for (StorageIndex j = 0; j < size; ++j) {
		for (MatIterator it(matEval, j); it; ++it) {
			StorageIndex i = internal::convert_index<StorageIndex>(it.index());
			Index r = it.row();
			Index c = it.col();

			StorageIndex jp = perm ? perm[j] : j;
			StorageIndex ip = perm ? perm[i] : i;

			if (Mode == int(Upper | Lower)) {
				Index k = count[StorageOrderMatch ? jp : ip]++;
				dest.innerIndexPtr()[k] = StorageOrderMatch ? ip : jp;
				dest.valuePtr()[k] = it.value();
			} else if (r == c) {
				Index k = count[ip]++;
				dest.innerIndexPtr()[k] = ip;
				dest.valuePtr()[k] = it.value();
			} else if (((Mode & Lower) == Lower && r > c) || ((Mode & Upper) == Upper && r < c)) {
				if (!StorageOrderMatch)
					std::swap(ip, jp);
				Index k = count[jp]++;
				dest.innerIndexPtr()[k] = ip;
				dest.valuePtr()[k] = it.value();
				k = count[ip]++;
				dest.innerIndexPtr()[k] = jp;
				dest.valuePtr()[k] = numext::conj(it.value());
			}
		}
	}
}

template<int _SrcMode, int _DstMode, typename MatrixType, int DstOrder>
void
permute_symm_to_symm(const MatrixType& mat,
					 SparseMatrix<typename MatrixType::Scalar, DstOrder, typename MatrixType::StorageIndex>& _dest,
					 const typename MatrixType::StorageIndex* perm)
{
	typedef typename MatrixType::StorageIndex StorageIndex;
	typedef typename MatrixType::Scalar Scalar;
	SparseMatrix<Scalar, DstOrder, StorageIndex>& dest(_dest.derived());
	typedef Matrix<StorageIndex, Dynamic, 1> VectorI;
	typedef evaluator<MatrixType> MatEval;
	typedef typename evaluator<MatrixType>::InnerIterator MatIterator;

	enum
	{
		SrcOrder = MatrixType::IsRowMajor ? RowMajor : ColMajor,
		StorageOrderMatch = int(SrcOrder) == int(DstOrder),
		DstMode = DstOrder == RowMajor ? (_DstMode == Upper ? Lower : Upper) : _DstMode,
		SrcMode = SrcOrder == RowMajor ? (_SrcMode == Upper ? Lower : Upper) : _SrcMode
	};

	MatEval matEval(mat);

	Index size = mat.rows();
	VectorI count(size);
	count.setZero();
	dest.resize(size, size);
	for (StorageIndex j = 0; j < size; ++j) {
		StorageIndex jp = perm ? perm[j] : j;
		for (MatIterator it(matEval, j); it; ++it) {
			StorageIndex i = it.index();
			if ((int(SrcMode) == int(Lower) && i < j) || (int(SrcMode) == int(Upper) && i > j))
				continue;

			StorageIndex ip = perm ? perm[i] : i;
			count[int(DstMode) == int(Lower) ? (std::min)(ip, jp) : (std::max)(ip, jp)]++;
		}
	}
	dest.outerIndexPtr()[0] = 0;
	for (Index j = 0; j < size; ++j)
		dest.outerIndexPtr()[j + 1] = dest.outerIndexPtr()[j] + count[j];
	dest.resizeNonZeros(dest.outerIndexPtr()[size]);
	for (Index j = 0; j < size; ++j)
		count[j] = dest.outerIndexPtr()[j];

	for (StorageIndex j = 0; j < size; ++j) {

		for (MatIterator it(matEval, j); it; ++it) {
			StorageIndex i = it.index();
			if ((int(SrcMode) == int(Lower) && i < j) || (int(SrcMode) == int(Upper) && i > j))
				continue;

			StorageIndex jp = perm ? perm[j] : j;
			StorageIndex ip = perm ? perm[i] : i;

			Index k = count[int(DstMode) == int(Lower) ? (std::min)(ip, jp) : (std::max)(ip, jp)]++;
			dest.innerIndexPtr()[k] = int(DstMode) == int(Lower) ? (std::max)(ip, jp) : (std::min)(ip, jp);

			if (!StorageOrderMatch)
				std::swap(ip, jp);
			if (((int(DstMode) == int(Lower) && ip < jp) || (int(DstMode) == int(Upper) && ip > jp)))
				dest.valuePtr()[k] = numext::conj(it.value());
			else
				dest.valuePtr()[k] = it.value();
		}
	}
}

}

// TODO implement twists in a more evaluator friendly fashion

namespace internal {

template<typename MatrixType, int Mode>
struct traits<SparseSymmetricPermutationProduct<MatrixType, Mode>> : traits<MatrixType>
{};

}

template<typename MatrixType, int Mode>
class SparseSymmetricPermutationProduct : public EigenBase<SparseSymmetricPermutationProduct<MatrixType, Mode>>
{
  public:
	typedef typename MatrixType::Scalar Scalar;
	typedef typename MatrixType::StorageIndex StorageIndex;
	enum
	{
		RowsAtCompileTime = internal::traits<SparseSymmetricPermutationProduct>::RowsAtCompileTime,
		ColsAtCompileTime = internal::traits<SparseSymmetricPermutationProduct>::ColsAtCompileTime
	};

  protected:
	typedef PermutationMatrix<Dynamic, Dynamic, StorageIndex> Perm;

  public:
	typedef Matrix<StorageIndex, Dynamic, 1> VectorI;
	typedef typename MatrixType::Nested MatrixTypeNested;
	typedef typename internal::remove_all<MatrixTypeNested>::type NestedExpression;

	SparseSymmetricPermutationProduct(const MatrixType& mat, const Perm& perm)
		: m_matrix(mat)
		, m_perm(perm)
	{
	}

	inline Index rows() const { return m_matrix.rows(); }
	inline Index cols() const { return m_matrix.cols(); }

	const NestedExpression& matrix() const { return m_matrix; }
	const Perm& perm() const { return m_perm; }

  protected:
	MatrixTypeNested m_matrix;
	const Perm& m_perm;
};

namespace internal {

template<typename DstXprType, typename MatrixType, int Mode, typename Scalar>
struct Assignment<DstXprType,
				  SparseSymmetricPermutationProduct<MatrixType, Mode>,
				  internal::assign_op<Scalar, typename MatrixType::Scalar>,
				  Sparse2Sparse>
{
	typedef SparseSymmetricPermutationProduct<MatrixType, Mode> SrcXprType;
	typedef typename DstXprType::StorageIndex DstIndex;
	template<int Options>
	static void run(SparseMatrix<Scalar, Options, DstIndex>& dst,
					const SrcXprType& src,
					const internal::assign_op<Scalar, typename MatrixType::Scalar>&)
	{
		// internal::permute_symm_to_fullsymm<Mode>(m_matrix,_dest,m_perm.indices().data());
		SparseMatrix<Scalar, (Options & RowMajor) == RowMajor ? ColMajor : RowMajor, DstIndex> tmp;
		internal::permute_symm_to_fullsymm<Mode>(src.matrix(), tmp, src.perm().indices().data());
		dst = tmp;
	}

	template<typename DestType, unsigned int DestMode>
	static void run(SparseSelfAdjointView<DestType, DestMode>& dst,
					const SrcXprType& src,
					const internal::assign_op<Scalar, typename MatrixType::Scalar>&)
	{
		internal::permute_symm_to_symm<Mode, DestMode>(src.matrix(), dst.matrix(), src.perm().indices().data());
	}
};

} // end namespace internal

} // end namespace Eigen

#endif // EIGEN_SPARSE_SELFADJOINTVIEW_H
